/* i386.s -- assembly support. */

/*
// QuickThreads -- Threads-building toolkit.
// Copyright (c) 1993 by David Keppel
//
// Permission to use, copy, modify and distribute this software and
// its documentation for any purpose and without fee is hereby
// granted, provided that the above copyright notice and this notice
// appear in all copies.  This software is provided as a
// proof-of-concept and for demonstration purposes; there is no
// representation about the suitability of this software for any
// purpose. */

/* NOTE: double-labeled `_name' and `name' for System V compatability.  */
/* NOTE: Mixed C/C++-style comments used. Sorry! */

/* Callee-save: %esi, %edi, %ebx, %ebp
// Caller-save: %eax, %ecx
// Can't tell: %edx (seems to work w/o saving it.)
//
// Assignment:
//
// See ``i386.h'' for the somewhat unconventional stack layout.  */


    .text
    .align 2

    .globl _qt_abort
    .globl qt_abort
    .globl _qt_block
    .globl qt_block
    .globl _qt_blocki
    .globl qt_blocki
    .globl _qt_align
    .globl qt_align

/* These all have the type signature
//
//    void *blocking (helper, arg0, arg1, new)
//
// On procedure entry, the helper is at 4(sp), args at 8(sp) and
// 12(sp) and the new thread's sp at 16(sp).  It *appears* that the
// calling convention for the 8X86 requires the caller to save all
// floating-point registers, this makes our life easy.  */

/* Halt the currently-running thread.  Save it's callee-save regs on
// to the stack, 32 bytes.  Switch to the new stack (next == 16+32(sp))
// and call the user function (f == 4+32(sp) with arguments: old sp
// arg1 (8+32(sp)) and arg2 (12+32(sp)).  When the user function is
// done, restore the new thread's state and return.
//
// `qt_abort' is (currently) an alias for `qt_block' because most of
// the work is shared.  We could save the insns up to `qt_common' by
// replicating, but w/o replicating we need an inital subtract (to
// offset the stack as if it had been a qt_block) and then a jump
// to qt_common.  For the cost of a jump, we might as well just do
// all the work.
//
// The helper function (4(sp)) can return a void* that is returned
// by the call to `qt_blockk{,i}'.  Since we don't touch %eax in
// between, we get that ``for free''.  */

_qt_abort:
qt_abort:
_qt_block:
qt_block:
_qt_blocki:
qt_blocki:
    pushl %ebp        /* Save callee-save, sp-=4. */
    pushl %esi        /* Save callee-save, sp-=4. */
    pushl %edi        /* Save callee-save, sp-=4. */
    pushl %ebx        /* Save callee-save, sp-=4. */
    movl %esp, %eax        /* Remember old stack pointer. */

qt_common:
    movl 32(%esp), %esp    /* Move to new thread. */
    pushl 28(%eax)        /* Push arg 2. */
    pushl 24(%eax)        /* Push arg 1. */
    pushl %eax        /* Push arg 0. */
    movl 20(%eax), %ebx    /* Get function to call. */
    call *%ebx        /* Call f. */
    addl $12, %esp        /* Pop args. */

    popl %ebx        /* Restore callee-save, sp+=4. */
    popl %edi        /* Restore callee-save, sp+=4. */
    popl %esi        /* Restore callee-save, sp+=4. */
    popl %ebp        /* Restore callee-save, sp+=4. */
_qt_align:
qt_align:
    ret            /* Resume the stopped function. */

    .globl _qt_tramp
    .globl qt_tramp
_qt_tramp:
qt_tramp:
    movl 12(%esp), %eax    /* Load 'qt_error' address */
    sub $4, %esp        /* Align stack pointer to 16-byte boundary */
    jmp *%eax        /* call 'qt_error' */
    hlt            /* 'qt_error' never returns */

/* Start a varargs thread. */

    .globl _qt_vstart
    .globl qt_vstart
_qt_vstart:
qt_vstart:
    pushl %edi        /* Push `pt' arg to `startup'. */
    call *%ebp        /* Call `startup'. */
    popl %eax        /* Clean up the stack. */

    call *%ebx        /* Call the user's function. */

    pushl %eax        /* Push return from user's. */
    pushl %edi        /* Push `pt' arg to `cleanup'. */
    call *%esi        /* Call `cleanup'. */

    hlt            /* `cleanup' never returns. */
